const app = getApp();
const nameMessages = require('../../utils/nameGenerationMessages.js');

Page({
  data: {
    birthDate: '',
    birthTime: '',
    region: ['北京市', '北京市', '东城区'],
    expectation: '',
    selectedReferences: [],
    referenceExpectations: [
      '希望孩子聪明伶俐，乐观向上',
      '希望孩子德才兼备，前程似锦',
      '希望孩子身体健康，平安喜乐',
      '希望孩子勤奋好学，志向远大',
      '希望孩子正直善良，乐于助人',
      '希望孩子坚韧不拔，勇往直前'
    ],
    baziInfo: null,
    wuxingAnalysis: '',
    isFormValid: false,
    formData: null,
    isGenerating: false,
    // 新增数据
    customXiyongshen: '',
    xiyongshenError: '',
    showBirthTimeMode: false,
    // 广告相关状态
    adCompleted: false,
    apiCompleted: false,
    apiResult: null,
    messageTimers: {
      firstTimer: null,
      interval: null
    }
  },

  onLoad(options) {
    // 获取从首页传递的表单数据
    try {
      const eventChannel = this.getOpenerEventChannel();
      if (eventChannel) {
        eventChannel.on('formData', (data) => {
          console.log('传统文化与典故结合页面接收到的表单数据:', data);
          console.log('传统文化与典故结合页面接收到的姓氏:', data.surname);
          this.setData({
            formData: data
          });
        });
      } else {
        console.log('eventChannel 不存在，可能直接打开了页面');
        // 设置默认值
        this.setData({
          formData: {
            surname: '张',
            gender: 'male',
            nameLength: '2'
          }
        });
      }
    } catch (error) {
      console.error('获取eventChannel时出错:', error);
      // 设置默认值
      this.setData({
        formData: {
          surname: '张',
          gender: 'male',
          nameLength: '2'
        }
      });
    }
    
    // 从缓存中读取保存的值（如果之前保存过）
    const savedData = wx.getStorageSync('combinedFormData');
    if (savedData) {
      this.setData({
        birthDate: savedData.birthDate || '',
        birthTime: savedData.birthTime || '',
        region: savedData.region || ['北京市', '北京市', '东城区'],
        expectation: savedData.expectation || '',
        customXiyongshen: savedData.customXiyongshen || ''
      });
    }
    
    // 创建激励广告实例
    this.createRewardedVideoAd();
  },
  
  // 处理喜用神输入
  onXiyongshenInput(e) {
    const value = e.detail.value;
    this.setData({
      customXiyongshen: value,
      xiyongshenError: this.validateXiyongshen(value)
    });
    this.saveFormData();
    this.checkFormValid();
  },
  
  // 验证喜用神输入
  validateXiyongshen(value) {
    if (!value) {
      return '请输入喜用神';
    }
    
    // 检查是否只包含"金木水火土"这几个字
    const validChars = ['金', '木', '水', '火', '土'];
    let isValid = true;
    let hasValidChar = false;
    
    for (const char of value) {
      if (!validChars.includes(char)) {
        isValid = false;
        break;
      }
      hasValidChar = true;
    }
    
    if (!isValid) {
      return '喜用神只能包含"金木水火土"这几个字';
    }
    
    if (!hasValidChar) {
      return '请输入至少一个五行元素';
    }
    
    return '';
  },
  
  // 切换到出生时间模式
  toggleBirthTimeMode() {
    this.setData({
      showBirthTimeMode: !this.data.showBirthTimeMode
    });
  },

  // 处理日期选择
  onDateChange(e) {
    this.setData({
      birthDate: e.detail.value
    });
    this.saveFormData();
    this.checkFormValid();
  },

  // 处理时间选择
  onTimeChange(e) {
    this.setData({
      birthTime: e.detail.value
    });
    this.saveFormData();
    this.checkFormValid();
  },

  // 处理地区选择
  onRegionChange(e) {
    this.setData({
      region: e.detail.value
    });
    this.saveFormData();
  },

  // 处理期望输入
  handleInput(e) {
    this.setData({
      expectation: e.detail.value
    });
    this.saveFormData();
    this.checkFormValid();
  },

  // 切换参考期望
  toggleReference(e) {
    const reference = e.currentTarget.dataset.reference;
    let selectedReferences = [...this.data.selectedReferences];
    
    if (selectedReferences.includes(reference)) {
      // 如果已选中，则取消选中
      selectedReferences = selectedReferences.filter(item => item !== reference);
    } else {
      // 修改为只能选择一条参考寄语
      selectedReferences = [reference];
    }
    
    this.setData({
      selectedReferences: selectedReferences
    });
    
    // 合并期望
    this.combineExpectations();
  },

  // 合并用户输入的期望和选择的参考期望
  combineExpectations() {
    // 如果有选中的参考寄语，合并后填入期望文本框
    if (this.data.selectedReferences.length > 0) {
      // 只有一条参考寄语，直接使用不需要join
      const combinedText = this.data.selectedReferences[0];
      
      this.setData({
        expectation: combinedText
      });
    }
    
    // 更新表单有效性
    this.checkFormValid();
    this.saveFormData();
  },

  // 清空选择的参考期望
  clearSelected() {
    this.setData({
      selectedReferences: [],
      expectation: '' // 同时清空期望寄语的内容
    });
    
    // 检查表单有效性
    this.checkFormValid();
    this.saveFormData();
  },
  
  // 保存表单数据到本地缓存
  saveFormData() {
    const formData = {
      birthDate: this.data.birthDate,
      birthTime: this.data.birthTime,
      region: this.data.region,
      expectation: this.data.expectation,
      customXiyongshen: this.data.customXiyongshen
    };
    wx.setStorageSync('combinedFormData', formData);
  },

  // 检查表单是否有效
  checkFormValid() {
    const { birthDate, birthTime, expectation, baziInfo, customXiyongshen, xiyongshenError } = this.data;
    
    // 表单验证逻辑修改：
    // 1. 可以通过直接输入有效的喜用神 + 期望寄语生成名字
    // 2. 也可以通过八字分析 + 期望寄语生成名字
    
    const hasExpectation = expectation.trim() !== '';
    const hasValidXiyongshen = customXiyongshen && !xiyongshenError;
    const hasBaziInfo = baziInfo !== null;
    
    // 两种模式都可以：直接输入喜用神或通过八字分析获取喜用神
    const isValid = hasExpectation && (hasValidXiyongshen || hasBaziInfo);
    
    this.setData({
      isFormValid: isValid
    });
    
    // 如果没有填写期望寄语，提示用户
    if ((hasValidXiyongshen || hasBaziInfo) && !hasExpectation) {
      wx.showToast({
        title: '请填写期望寄语',
        icon: 'none',
        duration: 1500
      });
    }
    
    // 如果没有有效的喜用神输入且没有八字分析，提示用户
    if (hasExpectation && !hasValidXiyongshen && !hasBaziInfo) {
      wx.showToast({
        title: '请输入喜用神或计算八字',
        icon: 'none',
        duration: 1500
      });
    }
    
    return isValid;
  },

  // 分析八字
  analyzeBazi() {
    if (!this.data.birthDate || !this.data.birthTime) {
      wx.showToast({
        title: '请选择完整的出生时间',
        icon: 'none'
      });
      return;
    }
    
    wx.showLoading({
      title: '正在分析数据...'
    });
    
    // 解析出生时间
    const [year, month, day] = this.data.birthDate.split('-');
    const [hour, minute] = this.data.birthTime.split(':');
    
    // 获取性别数据
    const sex = this.data.formData ? (this.data.formData.gender === 'male' ? 1 : 0) : 1;
    
    // 调用API
    wx.request({
      url: `https://yisuan.net/app/bazi-wuxing`,
      data: {
        _year: year,
        _month: month,
        _day: day,
        _hour: hour,
        _sex: sex
      },
      success: (res) => {
        const html = res.data;
        try {
          // 解析HTML
          const result = this.parseHTML(html);
          
          // 解析数据
          const baziParts = result.bazi.split('、');
          const baziInfo = {
            year: baziParts[0] || '',
            month: baziParts[1] || '',
            day: baziParts[2] || '',
            hour: baziParts[3] || ''
          };
          
          // 设置分析结果
          this.setData({
            baziInfo: baziInfo,
            wuxingAnalysis: result.lianghua,
            xiyongshen: result.xiyongshen,
            // 自动填充喜用神
            customXiyongshen: this.extractXiyongshen(result.xiyongshen)
          });
          
          // 保存分析结果到全局数据
          if (app.globalData) {
            app.globalData.baziResult = {
              ...result,
              processedBazi: baziInfo
            };
          }
          
          // 检查表单有效性
          this.checkFormValid();
          this.saveFormData();
          
          wx.showToast({
            title: '分析完成',
            icon: 'success'
          });
          
        } catch (error) {
          console.error('解析结果失败:', error);
          wx.showToast({
            title: '获取数据信息失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('请求API失败:', err);
        wx.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  },
  
  // HTML解析方法
  parseHTML: function(html) {
    // 解析基本信息
    const baziReg = /<tr class="has-background-warning">[\s\S]*?<td><b>八字<\/b><\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>/;
    const baziMatch = html.match(baziReg);
    const bazi = baziMatch ? 
      [baziMatch[1], baziMatch[2], baziMatch[3], baziMatch[4]].join('、') : 
      '未找到数据信息';
  
    // 解析汉字属性信息
    const wuxingReg = /<tr class="has-background-warning">[\s\S]*?<td><b>五行<\/b><\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>/;
    const wuxingMatch = html.match(wuxingReg);
    const wuxing = wuxingMatch ? 
      [wuxingMatch[1], wuxingMatch[2], wuxingMatch[3], wuxingMatch[4]].join('、') : 
      '未找到汉字属性信息';
  
    // 解析推荐用字
    const xiyongReg = /<h3>喜用神：<\/h3>([^<]+)/;
    const xiyongshenMatch = html.match(xiyongReg);
    const xiyongshen = xiyongshenMatch ? 
      xiyongshenMatch[1].replace(/<br>/, '').trim() : 
      '未找到推荐用字';
  
    // 解析评分数据
    const scoreMap = {};
    const scoreReg = /<label><b>(金|木|水|火|土)：([\d.]+)<\/b><\/label>/g;
    let scoreMatch;
    
    while ((scoreMatch = scoreReg.exec(html)) !== null) {
      const [_, element, value] = scoreMatch;
      scoreMap[element] = parseFloat(value);
    }
  
    // 确保完整数据（包含可能缺失的元素）
    ['金','木','水','火','土'].forEach(e => {
      if (!scoreMap.hasOwnProperty(e)) scoreMap[e] = 0;
    });
  
    // 按得分降序排序并格式化
    const sortedScores = Object.entries(scoreMap)
      .sort((a, b) => b[1] - a[1])
      .map(([k, v]) => `${k}：${v.toFixed(3)}`)
      .join('，');
  
    return {
      bazi: bazi,
      wuxing: wuxing,
      xiyongshen: xiyongshen,
      lianghua: sortedScores || '未找到评分数据'
    };
  },
  
  // 从喜用神提取五行元素
  extractXiyongshen(xiyongshen) {
    if (!xiyongshen) return '';
    
    // 提取喜用神中的五行元素
    let elements = '';
    const wuxingChars = ['金', '木', '水', '火', '土'];
    
    // 从字符串中提取所有元素
    for (const char of xiyongshen) {
      if (wuxingChars.includes(char) && !elements.includes(char)) {
        elements += char;
      }
    }
    
    // 如果没有找到元素，提供一个默认值
    return elements || '金木水火土';
  },

  // 创建激励广告实例
  createRewardedVideoAd() {
    // 创建广告实例
    if (wx.createRewardedVideoAd) {
      this.rewardedVideoAd = wx.createRewardedVideoAd({
        adUnitId: 'adunit-9e4cf424d63967f5'
      });

      // 监听广告加载事件
      this.rewardedVideoAd.onLoad(() => {
        console.log('激励广告加载成功');
      });

      // 监听广告错误事件
      this.rewardedVideoAd.onError((err) => {
        console.error('激励广告出错:', err);
        // 广告拉取异常视为播放完毕
        this.setData({
          adCompleted: true
        });
        
        // 如果API已完成，立即停止提示消息
        if (this.data.apiCompleted) {
          this.showMessages(false);
        }
        
        // 检查是否可以导航到结果页
        this.checkNavigationConditions();
      });

      // 监听广告关闭事件
      this.rewardedVideoAd.onClose((res) => {
        console.log('激励广告关闭', res);

        // 判断是否是正常关闭(用户看完了广告)
        if (res && res.isEnded) {
          console.log('激励广告完整观看');
          this.setData({
            adCompleted: true
          });
          
          // 如果API已完成，立即停止提示消息
          if (this.data.apiCompleted) {
            this.showMessages(false);
          }
          
          // 检查是否可以导航到结果页
          this.checkNavigationConditions();
        } else {
          // 不是正常结束时先停止消息循环
          this.showMessages(false);
          
          console.log('激励广告提前关闭');
          // 提示用户广告未播放完毕
          wx.showModal({
            title: '提示',
            content: '广告未播放完毕，无法生成名字，是否继续播放？',
            success: (res) => {
              if (res.confirm) {
                // 用户点击确定，继续播放广告
                this.showMessages(true); // 重新打开提示消息
                this.showRewardedVideoAd(); // 重新播放广告
              } else {
                // 用户点击取消，中断名字生成流程
                this.cancelNameGeneration();
              }
            }
          });
        }
      });
    }
  },

  // 显示激励广告
  showRewardedVideoAd() {
    if (this.rewardedVideoAd) {
      this.rewardedVideoAd.show()
        .catch(err => {
          // 失败重试
          this.rewardedVideoAd.load()
            .then(() => this.rewardedVideoAd.show())
            .catch(err => {
              console.error('激励广告显示失败:', err);
              // 广告显示异常视为播放完毕
              this.setData({
                adCompleted: true
              });
              
              // 如果API已完成，立即停止提示消息
              if (this.data.apiCompleted) {
                this.showMessages(false);
              }
              
              // 检查是否可以导航到结果页
              this.checkNavigationConditions();
            });
        });
    }
  },

  // 取消名字生成
  cancelNameGeneration() {
    // 重置状态
    this.setData({
      isGenerating: false,
      adCompleted: false,
      apiCompleted: false,
      apiResult: null
    });
    
    // 关闭所有提示
    this.showMessages(false);
    
    try {
      wx.hideToast();
    } catch (e) {
      console.error('hideToast error:', e);
    }
    
    try {
      wx.hideLoading();
    } catch (e) {
      console.error('hideLoading error:', e);
    }
  },

  // 检查是否满足导航条件
  checkNavigationConditions() {
    if (this.data.adCompleted && this.data.apiCompleted && this.data.apiResult) {
      // 确保消息循环已关闭
      this.showMessages(false);
      // 导航到结果页
      this.navigateToResultPage(this.data.apiResult);
    }
  },

  // 循环显示提示消息的方法
  showMessages(isShow) {
    // 清除可能存在的旧定时器
    if (this.data.messageTimers.firstTimer) {
      clearTimeout(this.data.messageTimers.firstTimer);
    }
    
    if (this.data.messageTimers.interval) {
      clearInterval(this.data.messageTimers.interval);
    }
    
    if (!isShow) {
      // 如果不需要显示消息，直接返回
      return;
    }
    
    // 使用五行典故结合法的特定提示消息
    const nameGenerationMessages = nameMessages.combinedGenerationMessages || nameMessages.baziGenerationMessages;
    let nameMessageIndex = 0;
    
    const showNameGenerationMessage = () => {
      // 先隐藏之前的提示
      try {
        wx.hideToast();
      } catch (e) {
        console.error('hideToast error:', e);
      }
      
      try {
        wx.hideLoading();
      } catch (e) {
        console.error('hideLoading error:', e);
      }
      
      // 显示新的提示 - 设置mask为false，让用户可以点击其他元素
      wx.showToast({
        title: nameGenerationMessages[nameMessageIndex],
        icon: 'none',
        duration: 10000,
        mask: false
      });
      
      // 更新消息索引，循环使用提示
      nameMessageIndex = (nameMessageIndex + 1) % nameGenerationMessages.length;
    };
    
    // 3秒后显示第一次提示
    const firstNameTimer = setTimeout(() => {
      if (this.data.isGenerating) {
        showNameGenerationMessage();
      }
    }, 3000);
    
    // 每4秒更新一次提示，直到请求完成
    const nameGenerationInterval = setInterval(() => {
      if (this.data.isGenerating) {
        showNameGenerationMessage();
      } else {
        clearInterval(nameGenerationInterval);
      }
    }, 4000);
    
    // 保存定时器引用
    this.setData({
      messageTimers: {
        firstTimer: firstNameTimer,
        interval: nameGenerationInterval
      }
    });
  },

  // 生成名字
  generateNames() {
    // 检查表单有效性
    if (!this.checkFormValid()) {
      return;
    }
    
    // 提示用户将播放广告
    wx.showModal({
      title: '提示',
      content: '计算名字大概需要30秒，为了分担服务成本，会播放一段广告，请耐心等待...',
      success: (res) => {
        if (res.confirm) {
          // 用户同意观看广告，开始生成名字流程
          this.startNameGeneration();
        } else {
          // 用户拒绝观看广告，中断流程
          console.log('用户拒绝观看广告');
        }
      }
    });
  },

  // 开始名字生成流程
  startNameGeneration() {
    // 重置状态
    this.setData({
      isGenerating: true,
      adCompleted: false,
      apiCompleted: false,
      apiResult: null
    });

    // 显示初始加载动画 - 确保mask为false允许点击
    wx.showLoading({
      title: '正在推荐名字\n请耐心等待...',
      mask: false
    });
    
    // 启动提示消息循环显示
    this.showMessages(true);
    
    // 准备请求数据并异步调用API
    this.callNameGenerationAPI()
      .then(result => {
        // 保存API结果
        this.setData({
          apiCompleted: true,
          apiResult: result
        });
        
        // 如果广告已完成，立即停止提示消息
        if (this.data.adCompleted) {
          this.showMessages(false);
        }
        
        // 检查是否可以导航到结果页
        this.checkNavigationConditions();
      })
      .catch(error => {
        console.error('生成名字失败:', error);
        this.setData({
          isGenerating: false,
          apiCompleted: true
        });
        
        // 无论成功失败都应该停止提示消息
        this.showMessages(false);
      });

    // 开始播放激励广告
    this.showRewardedVideoAd();
  },

  // 调用API生成名字
  callNameGenerationAPI() {
    // 返回Promise以支持异步流程控制
    return new Promise((resolve, reject) => {
      // 获取喜用神数据
      let wuxingElements;
      if (this.data.customXiyongshen) {
        // 使用直接输入的喜用神
        wuxingElements = this.data.customXiyongshen;
      } else if (this.data.xiyongshen) {
        // 如果已经分析过八字，使用分析结果中的喜用神
        wuxingElements = this.extractXiyongshen(this.data.xiyongshen);
      } else {
        // 如果都没有，显示错误
        reject(new Error('请输入喜用神或通过出生时间计算'));
        return;
      }
      
      // 获取姓氏和性别等数据
      const surname = this.data.formData ? this.data.formData.surname : '张';
      const gender = this.data.formData ? this.data.formData.gender : 'male';
      const nameLength = this.data.formData ? this.data.formData.nameLength : '2';
      
      // 获取用户期望
      const expectation = this.data.expectation.trim();
      
      console.log('五行典故结合取名页面准备发送的数据:', {
        surname: surname,
        gender: gender,
        nameLength: nameLength,
        expectation: expectation,
        wuxing: wuxingElements
      });
      
      // 调用真实API生成名字
      const api = require('../../utils/api.js');
      api.generateRealName({
        wuxing: wuxingElements, // 五行元素
        optimize_expect: expectation, // 期望描述
        surname: surname, // 姓氏
        gender: gender === 'male' ? '男' : '女', // 性别
        nameLength: nameLength, // 名字长度
        preference: "combined", // 取名偏好为五行典故结合法
        is_rare_character: this.data.formData.disableRareChars ? "y" : "n", 
        is_complex_character: this.data.formData.disableComplexChars ? "y" : "n",
        is_fixedname: this.data.formData ? this.data.formData.fixedChar : false,
        fixedposition: this.data.formData ? this.data.formData.fixedPosition : 'first',
        fixed_word: this.data.formData ? this.data.formData.fixedCharValue : '',
        namesNum: this.data.formData.namesNum || 10, // 添加名字生成数量参数
      })
      .then(result => {
        console.log('API返回的名字数据:', result);
        
        // 保存生成的名字数据
        this.saveNamesData(result);
        
        // 返回结果数据，完成Promise
        resolve(result);
      })
      .catch(error => {
        console.error('生成名字API调用失败:', error);
        wx.showToast({
          title: '生成名字失败，请重试',
          icon: 'none'
        });
        
        // 拒绝Promise
        reject(error);
      })
      .finally(() => {
        // 只隐藏loading，不影响消息循环
        try {
          wx.hideLoading();
        } catch (e) {
          console.error('hideLoading error:', e);
        }
      });
    });
  },

  // 保存名字数据到全局和本地存储
  saveNamesData(result) {
    // 获取姓氏和性别等数据
    const surname = this.data.formData ? this.data.formData.surname : '张';
    const gender = this.data.formData ? this.data.formData.gender : 'male';
    const nameLength = this.data.formData ? this.data.formData.nameLength : '2';
    
    // 获取用户期望
    const expectation = this.data.expectation.trim();
    
    // 构建要保存的数据对象
    const namesResultData = {
      surname: surname,
      gender: gender,
      nameLength: nameLength,
      baziInfo: this.data.baziInfo,
      wuxingData: this.data.wuxingAnalysis,
      namesData: result,
      expectation: expectation,
      wuxing: this.data.customXiyongshen,
      methodType: 'combined',
      namesNum: this.data.formData.namesNum || 10, // 添加名字生成数量参数
      // 传递定字取名参数
      is_fixedname: this.data.formData ? this.data.formData.fixedChar : false,
      fixedposition: this.data.formData ? this.data.formData.fixedPosition : 'first',
      fixed_word: this.data.formData ? this.data.formData.fixedCharValue : '',
      disableRareChars: this.data.formData.disableRareChars,
      disableComplexChars: this.data.formData.disableComplexChars
    };
    
    // 将API结果保存到全局变量
    const app = getApp();
    app.globalData = app.globalData || {};
    app.globalData.namesResult = namesResultData;
    
    // 同时也保存到本地存储作为备份
    wx.setStorageSync('namesResultData', namesResultData);
  },

  // 导航到结果页面
  navigateToResultPage(result) {
    // 确保重置生成状态
    this.setData({
      isGenerating: false
    });
    
    // 确保所有提示已关闭
    try {
      wx.hideToast();
    } catch (e) {
      console.error('hideToast error:', e);
    }
    
    try {
      wx.hideLoading();
    } catch (e) {
      console.error('hideLoading error:', e);
    }
    
    // 跳转到结果页面
    wx.navigateTo({
      url: '/pages/results/results?methodType=combined&source=combined&hasData=true',
      success: (res) => {
        console.log('五行典故结合取名页面传递给结果页的数据:', {
          surname: this.data.formData ? this.data.formData.surname : '张',
          gender: this.data.formData ? this.data.formData.gender : 'male',
          nameLength: this.data.formData ? this.data.formData.nameLength : '2',
          expectation: this.data.expectation.trim(),
          wuxing: this.data.customXiyongshen,
          methodType: 'combined'
        });
        
        // 通过eventChannel传递数据作为备份方式
        res.eventChannel.emit('resultData', {
          surname: this.data.formData ? this.data.formData.surname : '张',
          gender: this.data.formData ? this.data.formData.gender : 'male',
          nameLength: this.data.formData ? this.data.formData.nameLength : '2',
          baziInfo: this.data.baziInfo,
          wuxingData: this.data.wuxingAnalysis,
          namesData: result,
          expectation: this.data.expectation.trim(),
          wuxing: this.data.customXiyongshen,
          methodType: 'combined',
          // 传递定字取名参数
          is_fixedname: this.data.formData ? this.data.formData.fixedChar : false,
          fixedposition: this.data.formData ? this.data.formData.fixedPosition : 'first',
          fixed_word: this.data.formData ? this.data.formData.fixedCharValue : '',
          disableRareChars: this.data.formData.disableRareChars,
          disableComplexChars: this.data.formData.disableComplexChars
        });
      },
      fail: (err) => {
        console.error('导航到结果页面失败:', err);
        wx.showToast({
          title: '页面跳转失败',
          icon: 'none',
          duration: 2000
        });
      }
    });
  },
  
  // 页面卸载时清理资源
  onUnload() {
    // 清理消息定时器
    this.showMessages(false);
    
    // 清理广告相关资源
    if (this.rewardedVideoAd) {
      try {
        // 尝试销毁广告实例，不是所有小程序版本都支持此方法
        if (typeof this.rewardedVideoAd.destroy === 'function') {
          this.rewardedVideoAd.destroy();
        }
      } catch (e) {
        console.error('销毁广告实例失败:', e);
      }
    }
  }
}); 